AVL树的旋转详解

       二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素也就相当于是在顺序表中搜索元素，效率低下。因此，为了解决二叉搜索树中单支树的这种情况，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了AVL（平衡树）：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差(平衡因子)的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

故AVL树有两个最大的特点：

1、AVL树的左右子树都是也都是平衡树。
2、AVL树的平衡因子（左右子树高度之差）的绝对值不能超过1。

AVL树的介绍就到次，本篇文章主要讲解一下AVL树的四大旋转问题。为了方便理解，本文通过对将一组数插入到AVL树中的具体过程来帮助大家解开旋转的迷雾。

左单旋

当向较高右子树（不一定是根的右子树，也可以是根的左子树中的右子树）的右侧插入一个新的结点时，就会导致右侧的高度比左侧的高度高2，平衡因子失衡。（可以想象自己拿着一条绳子，右边的部分长一些，为了让左边的跟右边的一样长，是不是只要拿着左端往左边扯一下，就可使两端一样长了）同理，此时就需要往左旋转。

左单旋思路：

      先判端是否为左单旋的情况，如果是 ---->找到第一个失去平衡的结点，暂将其标记为P----> 将其右孩子标记为 PR ，---->右孩子PR的左子树标记为PRL (可能为NULL，如下图第一种情况)；然后使用PR代替原来P的位置 ---->将PR的左子树放在P的右孩子位置 ---->最后将P放到PR的左孩子位置。

右单旋：

       右单旋跟左单旋其实就是对称的，当向 较高左子树（不一定是根的左子树，也可以是根的右子树中的左子树）的左侧 插入一个新的结点时，就会导致左侧的高度比右侧的高度高-2，平衡因子失衡，故 此时就需要往右旋转。

右单旋思路：

      先判端是否为右单旋的情况，如果是 ---->找到第一个失去平衡的结点，暂将其标记为P----> 将其右孩子标记为 PL ，---->右孩子PL的右子树标记为PLR (可能为NULL，如下图第一种情况)；然后使用PL代替原来P的位置 ---->将PL的右子树放在P的左孩子位置 ---->最后将P放到PL的右孩子位置。

左右双旋：       

当在较高左子树的右侧插入一个结点时，导致较高左子树的双亲结点失去平衡。此时是较高左子树的右侧导致的失衡，仅仅 依靠单旋已经没法调整平衡了。

    判断是否为左右双旋的情况，如果是--->先使用左单旋，再使用右单旋。

右左双旋：

    当在较高右子树的左侧插入一个结点时，导致较高右子树的双亲结点失去平衡。此时是较高右子树的左侧导致的失衡，仅仅 依靠单旋已经没法调整平衡了。

    判断是否为右左双旋的情况，如果是--->先使用右单旋，再使用左单旋。

具体实现

#include <iostream>
using namespace std;

template <typename T, typename V>
struct AVLTreeNode
{
	AVLTreeNode()
	{}

	AVLTreeNode(T key, V value)
		:_key(key)
		, _value(value)
		, _bf(0)
		, _pLeft(NULL)
		, _pRight(NULL)
		, _pParent(NULL)
	{}

	T _key;
	V _value;
	int _bf;
	AVLTreeNode<T, V>* _pLeft;
	AVLTreeNode<T, V>* _pRight;
	AVLTreeNode<T, V>* _pParent;
};

template <typename T, typename V>
class AVLTree
{
	typedef AVLTreeNode<int, int> Node;
	typedef Node* PNode;

public:
	AVLTree()
		:_pRoot(NULL)
	{}

	void Insert(T key, V value)
	{
		_Insert(_pRoot, key, value);
	}

	void Delete(T key, V value)
	{
		_Delete(_pRoot, key, value);
	}

	void InOrder()
	{
		_InOrder(_pRoot);
	}

	bool Isbalance()
	{
		return _Isbalance(_pRoot);
	}

private:

	int GetHeight(PNode Root)
	{
		if (NULL == Root)
			return 0;

		int Left = GetHeight(Root->_pLeft);
		int Right = GetHeight(Root->_pRight);
		return (Left > Right) ? (Left + 1) : (Right + 1);
	}

	bool _Isbalance(PNode Root)
	{
		if (NULL == Root)
			return true;
		
		int LHeight = GetHeight(Root->_pLeft);
		int RHeight = GetHeight(Root->_pRight);
		int bf = RHeight - LHeight;
		if (abs(bf) >= 2)
			return false;
		else
			return _Isbalance(Root->_pLeft) && _Isbalance(Root->_pRight);
	}

	PNode Find(PNode& Root, T key, V value)
	{
		PNode pCur = Root;
		while (pCur)
		{
			if (key < pCur->_key)
				pCur = pCur->_pLeft;
			else if (key > pCur->_key)
				pCur = pCur->_pRight;
			else
				return pCur;
		}
		return NULL;
	}

	PNode FirstOfInOder(PNode& Root)
	{
		if (NULL == Root)
			return NULL;
		PNode pCur = Root;
		while (pCur->_pLeft)
		{
			pCur = pCur->_pLeft;
		}
		return pCur;
	}

	void RotateL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;

		//更新pParent的右
		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;

		//更新PSubR的左和双亲
		pSubR->_pLeft = pParent;
		
		PNode parent = pParent->_pParent;
		pSubR->_pParent = parent;

		//更新pParent的双亲
		//pParent为根
		if (parent == NULL)
			_pRoot = pSubR;

		//pParent为双亲的左
		else if (pParent == parent->_pLeft)
			parent->_pLeft = pSubR;
		//pParent为双亲的右
		else if (pParent == parent->_pRight)
			parent->_pRight = pSubR;

		pParent->_pParent = pSubR;

		pParent->_bf = 0;
		pSubR->_bf = 0;
	}

	void RotateR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;

		//更新pParent的左
		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;

		//更新pSubL的位置
		PNode parent = pParent->_pParent;
		pSubL->_pRight = pParent;
		pSubL->_pParent = parent;

		//更新pParent的双亲结点的指向
		//pParent为根
		if (NULL == parent)
			_pRoot = pSubL;
		
		//pParent为双亲结点的左孩子
		else if (pParent == parent->_pLeft)
			parent->_pLeft = pSubL;

		//pParent为双亲结点的右孩子
		else if (pParent == parent->_pRight)
			parent->_pRight = pSubL;

		pParent->_pParent = pSubL;

		pParent->_bf = 0;
		pSubL->_bf = 0;
	}

	void RotateLR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;
		int LR = pSubLR->_bf;

		RotateL(pParent->_pLeft);
		RotateR(pParent);

		PNode parent = pParent->_pParent;
		if (parent)
		{
			int left = GetHeight(parent->_pLeft);
			int right = GetHeight(parent->_pRight);

			parent->_bf = right - left;
		}

		if (LR == -1)
			pParent->_bf = 1;

		else if (LR == 1)
			pSubL->_bf = -1;
	}

	void RotateRL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;
		int RL = pSubRL->_bf;

		PNode parent = pParent->_pParent;
		if (parent)
			parent->_bf++;

		RotateR(pParent->_pRight);
		RotateL(pParent);

		if (RL == 1)
			pParent->_bf = -1;
		else if (RL == -1)
			pSubR->_bf = 1;
	}

	//旋转平衡调整
	void _Rotate(PNode& pParent)
	{
		if(pParent)
		{
			if (pParent->_bf == -2)
			{
				if (pParent->_pLeft->_bf == -1)//较高左子树的左侧---右单旋
					RotateR(pParent);
				else if (pParent->_pLeft->_bf == 1)//较高左子树的右侧---左右双旋
					RotateLR(pParent);
			}
			else if (pParent->_bf == 2)
			{
				if (pParent->_pRight->_bf == 1)//较高右子树的右侧---左单旋
					RotateL(pParent);
				else if (pParent->_pRight->_bf == -1)//较高右子树的左侧---右左双旋
					RotateRL(pParent);
			}
		}
	}

	//调整平衡因子
	void AdjustBf(PNode& pCur)
	{
		PNode pParent = pCur->_pParent;
		while (pParent)
		{
			if (pCur == pParent->_pLeft)
				pParent->_bf--;
			else
				pParent->_bf++;

			if (0 == pParent->_bf)
				break;
			else if (1 == pParent->_bf || -1 == pParent->_bf)
			{
				pCur = pParent;
				pParent = pCur->_pParent;
			}
			else
			{
				_Rotate(pParent);
				break;
			}
		}
	}

private:
	void _InOrder(PNode& Root)
	{
		if (NULL == Root)
			return;
		_InOrder(Root->_pLeft);
		cout << "<" << Root->_key << "," << Root->_value << ">" << endl;
		_InOrder(Root->_pRight);
	}

	bool _Insert(PNode& Root, T key, V value)
	{
		if (NULL == Root)
		{
			Root = new Node(key, value);
			return true;
		}

		PNode pCur = Root;
		PNode pParent = NULL;

		while (pCur)
		{
			if (key < pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else if (key > pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
			else
				return false;
		}

		pCur = new Node(key, value);

		if (key < pParent->_key)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;

		pCur->_pParent = pParent;
		AdjustBf(pCur);

		return true;
	}

private:
	PNode _pRoot;
};


void TestAVLTre()
{
	AVLTree<int, int> avlt;
	//int arr[] = { 11, 7, 18, 3 };
	int arr[] = { 70, 50, 90, 30, 60,55};
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		avlt.Insert(arr[i], i);
	}
	avlt.InOrder();
	//avlt.Insert(4, 4);
	if (avlt.Isbalance())
		cout << "this Tree is AVLTree" << endl;
	else
		cout << "this Tree is not AVLTree" << endl;
}